package com.example.graph;

import java.util.*;

public class Leetcode133_CloneGraph {
    public static void main(String[] args) {

    }

    static class Solution {
        public Node cloneGraph(Node node) {
//            return dfsClone(node, new HashMap<>());
            return bfsClone(node);
        }

        /**
         * 使用一个哈希表 visited 存储所有已被访问和克隆的节点。哈希表中的 key 是原始图中的节点，value 是克隆图中的对应节点。
         * 将题目给定的节点添加到队列。克隆该节点并存储到哈希表中。
         *
         * 每次从队列首部取出一个节点，遍历该节点的所有邻接点。
         * 如果某个邻接点已被访问，则该邻接点一定在 visited 中，那么从 visited 获得该邻接点，
         * 否则创建一个新的节点存储在 visited 中，并将邻接点添加到队列。将克隆的邻接点添加到克隆图对应节点的邻接表中。
         * 重复上述操作直到队列为空，则整个图遍历结束。
         *
         * @param node
         * @return
         */
        private Node bfsClone(Node node) {
            if (node == null) return null;
            Map<Node, Node> visited = new HashMap<>();// key 是原始图中的节点，value 是克隆图中的对应节点。
            Queue<Node> queue = new LinkedList<>();
            queue.offer(node);
            visited.put(node, new Node(node.val, new ArrayList<>()));

            while (!queue.isEmpty()) {
                Node tmp = queue.poll();
                // 遍历访问邻居节点并克隆
                for (Node neighbor : tmp.neighbors) {
                    if (!visited.containsKey(neighbor)) {
                        visited.put(neighbor, new Node(neighbor.val, new ArrayList<>()));
                        queue.offer(neighbor);
                    }
                    // 更新当前节点的邻居列表
                    visited.get(tmp).neighbors.add(visited.get(neighbor));
                }

            }

            return visited.get(node);
        }

        /**
         * 从给定节点开始遍历图。
         * 如果某个节点已经被访问过，则返回其克隆图中的对应节点。
         * 如果当前访问的节点不在哈希表中，则创建它的克隆节点并存储在哈希表中
         *
         * @param node
         * @param visited 防止多次遍历同一个节点，陷入死循环，使用HashMap记录已经被克隆过的节点, key 是原始图中的节点，value 是克隆图中的对应节点。
         */
        private Node dfsClone(Node node, Map<Node, Node> visited) {
            if (node == null) return null;

            // 如果该节点已经被访问过了，则直接从哈希表中取出对应的克隆节点返回
            if (visited.containsKey(node)) return visited.get(node);

            // 克隆出节点
            Node cloneNode = new Node(node.val, new ArrayList<>());
            visited.put(node, cloneNode);

            // dfs克隆邻居节点
            for (Node neighbor : node.neighbors) {
                cloneNode.neighbors.add(dfsClone(neighbor, visited));

            }

            return cloneNode;
        }

        class Node {
            public int val;
            public List<Node> neighbors;
            public Node() {
                val = 0;
                neighbors = new ArrayList<Node>();
            }
            public Node(int _val) {
                val = _val;
                neighbors = new ArrayList<Node>();
            }
            public Node(int _val, ArrayList<Node> _neighbors) {
                val = _val;
                neighbors = _neighbors;
            }
        }
    }
}
